package com.bawei.lib_common.aop

import android.content.Context
import android.util.Log
import com.alibaba.android.arouter.launcher.ARouter
import com.bawei.lib_storage.mmkv.AuthMMKV
import com.tencent.mmkv.MMKV

/**
 * 登录管理器
 * 提供登录状态管理、检查、跳转等功能
 */
object LoginManager {
    
    private const val TAG = "LoginManager"
    
    // 标记是否正在显示登录页面，避免重复跳转
    private var isShowingLoginPage = false
    
    // 当前显示的登录页面类型
    private var currentLoginPageType: LoginPageType = LoginPageType.NONE
    
    // 上次跳转的时间戳，用于防止短时间内重复跳转
    private var lastJumpTime: Long = 0
    
    // 最小跳转间隔（毫秒）
    private const val MIN_JUMP_INTERVAL = 1000L
    
    // 标记用户是否主动退出登录，防止自动跳转
    private var isUserLogout = false
    
    // 退出登录后的冷却时间（毫秒），在此期间不自动跳转
    private const val LOGOUT_COOLDOWN = 5000L
    
    // 退出登录的时间戳
    private var logoutTime: Long = 0
    
    // 标记用户是否主动关闭登录页面，防止自动跳转
    private var isUserClosedLoginPage = false
    
    // 关闭登录页面后的冷却时间（毫秒），在此期间不自动跳转
    private const val CLOSE_LOGIN_COOLDOWN = 3000L
    
    // 关闭登录页面的时间戳
    private var closeLoginTime: Long = 0
    
    /**
     * 登录页面类型枚举
     */
    enum class LoginPageType {
        NONE,           // 无登录页面显示
        QUICK_LOGIN,    // 一键登录页面
        NORMAL_LOGIN    // 普通登录页面
    }
    
    /**
     * 检查MMKV是否已初始化
     */
    private fun isMMKVInitialized(): Boolean {
        return try {
            MMKV.mmkvWithID("test")
            true
        } catch (e: IllegalStateException) {
            Log.e(TAG, "MMKV未初始化: ${e.message}")
            false
        }
    }
    
    /**
     * 检查是否在短时间内重复跳转
     */
    private fun isJumpingTooFrequently(): Boolean {
        val currentTime = System.currentTimeMillis()
        val timeDiff = currentTime - lastJumpTime
        if (timeDiff < MIN_JUMP_INTERVAL) {
            Log.d(TAG, "跳转过于频繁，间隔时间: ${timeDiff}ms，最小间隔: ${MIN_JUMP_INTERVAL}ms")
            return true
        }
        return false
    }
    
    /**
     * 检查是否在退出登录冷却期内
     */
    private fun isInLogoutCooldown(): Boolean {
        if (!isUserLogout) {
            return false
        }
        
        val currentTime = System.currentTimeMillis()
        val timeDiff = currentTime - logoutTime
        if (timeDiff < LOGOUT_COOLDOWN) {
            Log.d(TAG, "在退出登录冷却期内，跳过自动跳转，剩余时间: ${LOGOUT_COOLDOWN - timeDiff}ms")
            return true
        } else {
            // 冷却期结束，重置标记
            isUserLogout = false
            logoutTime = 0
            Log.d(TAG, "退出登录冷却期结束，重置标记")
            return false
        }
    }
    
    /**
     * 检查是否在关闭登录页面冷却期内
     */
    private fun isInCloseLoginCooldown(): Boolean {
        if (!isUserClosedLoginPage) {
            return false
        }
        
        val currentTime = System.currentTimeMillis()
        val timeDiff = currentTime - closeLoginTime
        if (timeDiff < CLOSE_LOGIN_COOLDOWN) {
            Log.d(TAG, "在关闭登录页面冷却期内，跳过自动跳转，剩余时间: ${CLOSE_LOGIN_COOLDOWN - timeDiff}ms")
            return true
        } else {
            // 冷却期结束，重置标记
            isUserClosedLoginPage = false
            closeLoginTime = 0
            Log.d(TAG, "关闭登录页面冷却期结束，重置标记")
            return false
        }
    }
    
    /**
     * 检查是否已登录
     */
    fun isLoggedIn(): Boolean {
        if (!isMMKVInitialized()) {
            Log.e(TAG, "MMKV未初始化，无法检查登录状态")
            return false
        }
        return AuthMMKV.hasLogin()
    }
    
    /**
     * 获取当前token
     */
    fun getToken(): String {
        if (!isMMKVInitialized()) {
            Log.e(TAG, "MMKV未初始化，无法获取token")
            return ""
        }
        return AuthMMKV.token
    }
    
    /**
     * 设置登录token
     */
    fun setToken(token: String) {
        if (!isMMKVInitialized()) {
            Log.e(TAG, "MMKV未初始化，无法设置token")
            return
        }
        AuthMMKV.token = token
        Log.d(TAG, "设置登录token: $token")
    }
    
    /**
     * 清除登录状态
     */
    fun clearLogin() {
        if (!isMMKVInitialized()) {
            Log.e(TAG, "MMKV未初始化，无法清除登录状态")
            return
        }
        AuthMMKV.token = ""
        Log.d(TAG, "清除登录状态")
    }
    
    /**
     * 跳转到一键登录页面
     */
    fun navigateToQuickLogin(context: Context): Boolean {
        Log.d(TAG, "尝试跳转到一键登录页面，当前状态: isShowingLoginPage=$isShowingLoginPage, currentLoginPageType=$currentLoginPageType")
        
        // 检查是否在退出登录冷却期内
        if (isInLogoutCooldown()) {
            Log.d(TAG, "在退出登录冷却期内，跳过跳转")
            return false
        }
        
        // 检查是否在关闭登录页面冷却期内
        if (isInCloseLoginCooldown()) {
            Log.d(TAG, "在关闭登录页面冷却期内，跳过跳转")
            return false
        }
        
        // 检查是否在短时间内重复跳转
        if (isJumpingTooFrequently()) {
            Log.d(TAG, "跳转过于频繁，跳过跳转")
            return false
        }
        
        if (isShowingLoginPage) {
            Log.d(TAG, "登录页面已显示，跳过跳转")
            return false
        }
        
        Log.d(TAG, "跳转到一键登录页面")
        isShowingLoginPage = true
        currentLoginPageType = LoginPageType.QUICK_LOGIN
        lastJumpTime = System.currentTimeMillis()
        ARouter.getInstance()
            .build("/module_mine/QuickLoginActivity")
            .navigation(context)
        return true
    }
    
    /**
     * 跳转到普通登录页面
     */
    fun navigateToNormalLogin(context: Context): Boolean {
        Log.d(TAG, "尝试跳转到普通登录页面，当前状态: isShowingLoginPage=$isShowingLoginPage, currentLoginPageType=$currentLoginPageType")
        
        // 检查是否在短时间内重复跳转
        if (isJumpingTooFrequently()) {
            Log.d(TAG, "跳转过于频繁，跳过跳转")
            return false
        }
        
        if (isShowingLoginPage) {
            Log.d(TAG, "登录页面已显示，跳过跳转")
            return false
        }
        
        Log.d(TAG, "跳转到普通登录页面")
        isShowingLoginPage = true
        currentLoginPageType = LoginPageType.NORMAL_LOGIN
        lastJumpTime = System.currentTimeMillis()
        ARouter.getInstance()
            .build("/module_mine/LoginActivity")
            .navigation(context)
        return true
    }
    
    /**
     * 跳转到登录页面（默认一键登录）
     */
    fun navigateToLogin(context: Context): Boolean {
        Log.d(TAG, "调用默认跳转方法，跳转到一键登录页面")
        return navigateToQuickLogin(context)
    }
    
    /**
     * 标记登录页面已关闭
     */
    fun onLoginPageClosed() {
        Log.d(TAG, "登录页面已关闭: $currentLoginPageType")
        isShowingLoginPage = false
        currentLoginPageType = LoginPageType.NONE
        
        // 设置用户主动关闭登录页面的标记，防止自动跳转
        isUserClosedLoginPage = true
        closeLoginTime = System.currentTimeMillis()
        
        Log.d(TAG, "状态已重置: isShowingLoginPage=$isShowingLoginPage, currentLoginPageType=$currentLoginPageType")
        Log.d(TAG, "设置关闭登录页面冷却期标记")
    }
    
    /**
     * 检查登录状态，如果未登录则跳转到登录页面
     */
    fun checkLoginAndNavigate(context: Context, message: String = "请先登录"): Boolean {
        if (isLoggedIn()) {
            Log.d(TAG, "用户已登录")
            return true
        } else {
            Log.d(TAG, "用户未登录: $message")
            return navigateToLogin(context)
        }
    }
    
    /**
     * 检查登录状态，如果未登录则跳转到登录页面（Fragment版本）
     */
    fun checkLoginAndNavigate(fragment: androidx.fragment.app.Fragment, message: String = "请先登录"): Boolean {
        val context = fragment.activity ?: fragment.context
        return if (context != null) {
            checkLoginAndNavigate(context, message)
        } else {
            Log.w(TAG, "无法获取Context，无法跳转")
            false
        }
    }
    
    /**
     * 登录成功后的处理
     */
    fun onLoginSuccess(token: String) {
        setToken(token)
        isShowingLoginPage = false // 登录成功后清除标记
        currentLoginPageType = LoginPageType.NONE
        
        // 登录成功后清除退出登录标记
        isUserLogout = false
        logoutTime = 0
        
        // 登录成功后清除关闭登录页面标记
        isUserClosedLoginPage = false
        closeLoginTime = 0
        
        Log.d(TAG, "登录成功，token已保存，清除所有冷却期标记")
    }
    
    /**
     * 登出处理
     */
    fun logout() {
        clearLogin()
        isShowingLoginPage = false // 登出后清除标记
        currentLoginPageType = LoginPageType.NONE
        
        // 设置退出登录标记，防止自动跳转
        isUserLogout = true
        logoutTime = System.currentTimeMillis()
        
        // 登出时也清除关闭登录页面标记
        isUserClosedLoginPage = false
        closeLoginTime = 0
        
        Log.d(TAG, "用户登出，设置冷却期标记")
    }
    
    /**
     * 获取当前登录页面类型
     */
    fun getCurrentLoginPageType(): LoginPageType {
        return currentLoginPageType
    }
    
    /**
     * 检查是否正在显示登录页面
     */
    fun isShowingLoginPage(): Boolean {
        return isShowingLoginPage
    }
    
    /**
     * 强制重置状态（用于调试）
     */
    fun forceReset() {
        Log.d(TAG, "强制重置状态")
        isShowingLoginPage = false
        currentLoginPageType = LoginPageType.NONE
        lastJumpTime = 0
        isUserLogout = false
        logoutTime = 0
        isUserClosedLoginPage = false
        closeLoginTime = 0
    }
} 